package com.swind.fast.common.util;

// import io.minio.MinioClient;
// import io.minio.errors.*;
import io.minio.*;
import lombok.extern.slf4j.Slf4j;
import com.swind.fast.common.util.filter.FileTypeFilter;
import com.swind.fast.common.util.filter.StrAttackFilter;
import org.springframework.web.multipart.MultipartFile;
// import org.xmlpull.v1.XmlPullParserException;

import java.io.IOException;
import java.io.InputStream;
import java.net.URLDecoder;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

/**
 * minio文件上传工具类
 */

@Slf4j
public class MinioUtil {
    // private static String minioUrl;
    // private static String minioName;
    // private static String minioPass;
    // private static String bucketName;

    // public static void setMinioUrl(String minioUrl) {
    //     MinioUtil.minioUrl = minioUrl;
    // }

    // public static void setMinioName(String minioName) {
    //     MinioUtil.minioName = minioName;
    // }

    // public static void setMinioPass(String minioPass) {
    //     MinioUtil.minioPass = minioPass;
    // }

    // public static void setBucketName(String bucketName) {
    //     MinioUtil.bucketName = bucketName;
    // }

    // public static String getMinioUrl() {
    //     return minioUrl;
    // }

    // public static String getBucketName() {
    //     return bucketName;
    // }

    // private static MinioClient minioClient = null;

    // /**
    //  * 上传文件
    //  * @param file
    //  * @return
    //  */
    // public static String upload(MultipartFile file, String bizPath, String customBucket) {
    //     String file_url = "";
    //     //update-begin-author:wangshuai date:20201012 for: 过滤上传文件夹名特殊字符，防止攻击
    //     bizPath=StrAttackFilter.filter(bizPath);
    //     //update-end-author:wangshuai date:20201012 for: 过滤上传文件夹名特殊字符，防止攻击
    //     String newBucket = bucketName;
    //     if(oConvertUtils.isNotEmpty(customBucket)){
    //         newBucket = customBucket;
    //     }
    //     try {
    //         initMinio(minioUrl, minioName,minioPass);
    //         // 检查存储桶是否已经存在
    //         if(minioClient.bucketExists(newBucket)) {
    //             log.info("Bucket already exists.");
    //         } else {
    //             // 创建一个名为ota的存储桶
    //             minioClient.makeBucket(newBucket);
    //             log.info("create a new bucket.");
    //         }
    //         InputStream stream = file.getInputStream();
    //         // 获取文件名
    //         String orgName = file.getOriginalFilename();
    //         if("".equals(orgName)){
    //             orgName=file.getName();
    //         }
    //         orgName = CommonUtils.getFileName(orgName);
    //         String objectName = bizPath+"/"+orgName.substring(0, orgName.lastIndexOf(".")) + "_" + System.currentTimeMillis() + orgName.substring(orgName.indexOf("."));

    //         // 使用putObject上传一个本地文件到存储桶中。
    //         minioClient.putObject(newBucket,objectName, stream,stream.available(),"application/octet-stream");
    //         stream.close();
    //         file_url = minioUrl+newBucket+"/"+objectName;
    //     }catch (IOException e){
    //         log.error(e.getMessage(), e);
    //     } catch (InvalidKeyException e) {
    //         log.error(e.getMessage(), e);
    //     } catch (NoSuchAlgorithmException e) {
    //         log.error(e.getMessage(), e);
    //     } catch (NoResponseException e) {
    //         log.error(e.getMessage(), e);
    //     } catch (XmlPullParserException e) {
    //         log.error(e.getMessage(), e);
    //     } catch (InvalidArgumentException e) {
    //         log.error(e.getMessage(), e);
    //     } catch (RegionConflictException e) {
    //         log.error(e.getMessage(), e);
    //     } catch (InvalidBucketNameException e) {
    //         log.error(e.getMessage(), e);
    //     } catch (ErrorResponseException e) {
    //         log.error(e.getMessage(), e);
    //     } catch (InternalException e) {
    //         log.error(e.getMessage(), e);
    //     } catch (InsufficientDataException e) {
    //         log.error(e.getMessage(), e);
    //     }
    //     return file_url;
    // }

    // /**
    //  * 文件上传
    //  * @param file
    //  * @param bizPath
    //  * @return
    //  */
    // public static String upload(MultipartFile file, String bizPath) {
    //     return  upload(file,bizPath,null);
    // }

    // /**
    //  * 获取文件流
    //  * @param bucketName
    //  * @param objectName
    //  * @return
    //  */
    // public static InputStream getMinioFile(String bucketName,String objectName){
    //     InputStream inputStream = null;
    //     try {
    //         initMinio(minioUrl, minioName, minioPass);
    //         inputStream = minioClient.getObject(bucketName, objectName);
    //     } catch (Exception e) {
    //         log.info("文件获取失败" + e.getMessage());
    //     }
    //     return inputStream;
    // }

    // /**
    //  * 删除文件
    //  * @param bucketName
    //  * @param objectName
    //  * @throws Exception
    //  */
    // public static void removeObject(String bucketName, String objectName) {
    //     try {
    //         initMinio(minioUrl, minioName,minioPass);
    //         minioClient.removeObject(bucketName, objectName);
    //     }catch (Exception e){
    //         log.info("文件删除失败" + e.getMessage());
    //     }
    // }

    // /**
    //  * 获取文件外链
    //  * @param bucketName
    //  * @param objectName
    //  * @param expires
    //  * @return
    //  */
    // public static String getObjectURL(String bucketName, String objectName, Integer expires) {
    //     initMinio(minioUrl, minioName,minioPass);
    //     try{
    //         String url = minioClient.presignedGetObject(bucketName, objectName, expires);
    //         return URLDecoder.decode(url,"UTF-8");
    //     }catch (Exception e){
    //         log.info("文件路径获取失败" + e.getMessage());
    //     }
    //     return null;
    // }

    // public static String getObjectURL(String objectName, Integer expires) {
    //     initMinio(minioUrl, minioName, minioPass);
    //     try {
    //         String url = minioClient.presignedGetObject(bucketName, objectName, expires);
    //         return URLDecoder.decode(url,"UTF-8");
    //     } catch (Exception e) {
    //         log.info("文件路径获取失败" + e.getMessage());
    //     }
    //     return null;
    // }

    // /**
    //  * 初始化客户端
    //  * @param minioUrl
    //  * @param minioName
    //  * @param minioPass
    //  * @return
    //  */
    // private static MinioClient initMinio(String minioUrl, String minioName,String minioPass) {
    //     if (minioClient == null) {
    //         try {
    //             minioClient = new MinioClient(minioUrl, minioName,minioPass);
    //         } catch (InvalidEndpointException e) {
    //             e.printStackTrace();
    //         } catch (InvalidPortException e) {
    //             e.printStackTrace();
    //         }
    //     }
    //     return minioClient;
    // }

    // /**
    //  * 上传文件到minio
    //  * @param stream
    //  * @param relativePath
    //  * @return
    //  */
    // public static String upload(InputStream stream,String relativePath) throws IOException, InvalidKeyException, NoSuchAlgorithmException, InsufficientDataException, InternalException, NoResponseException, InvalidBucketNameException, XmlPullParserException, ErrorResponseException, RegionConflictException, InvalidArgumentException {
    //     initMinio(minioUrl, minioName,minioPass);
    //     if(minioClient.bucketExists(bucketName)) {
    //         log.info("Bucket already exists.");
    //     } else {
    //         // 创建一个名为ota的存储桶
    //         minioClient.makeBucket(bucketName);
    //         log.info("create a new bucket.");
    //     }
    //     minioClient.putObject(bucketName,relativePath, stream, stream.available(),"application/octet-stream");
    //     stream.close();
    //     return minioUrl+bucketName+"/"+relativePath;
    // }

    // // fileUrl = http://127.0.0.1:59000/swinddemo/file/WechatIMG156_1626331033765.jpeg
    // public static String getObjectNameByUrl(String fileUrl) {
    //     Integer bucketIndex = fileUrl.indexOf(bucketName);
    //     String objectName = fileUrl.substring(bucketIndex + bucketName.length() + 1);
    //     return objectName;
    // }

    private static String minioUrl;
    private static String minioName;
    private static String minioPass;
    private static String bucketName;

    public static void setMinioUrl(String minioUrl) {
        MinioUtil.minioUrl = minioUrl;
    }

    public static void setMinioName(String minioName) {
        MinioUtil.minioName = minioName;
    }

    public static void setMinioPass(String minioPass) {
        MinioUtil.minioPass = minioPass;
    }

    public static void setBucketName(String bucketName) {
        MinioUtil.bucketName = bucketName;
    }

    public static String getMinioUrl() {
        return minioUrl;
    }

    public static String getBucketName() {
        return bucketName;
    }

    private static MinioClient minioClient = null;

    /**
     * 上传文件
     * @param file
     * @return
     */
    public static String upload(MultipartFile file, String bizPath, String customBucket) {
        String file_url = "";
        //update-begin-author:wangshuai date:20201012 for: 过滤上传文件夹名特殊字符，防止攻击
        bizPath=StrAttackFilter.filter(bizPath);
        //update-end-author:wangshuai date:20201012 for: 过滤上传文件夹名特殊字符，防止攻击
        String newBucket = bucketName;
        if(oConvertUtils.isNotEmpty(customBucket)){
            newBucket = customBucket;
        }
        try {
            initMinio(minioUrl, minioName,minioPass);
            // 检查存储桶是否已经存在
            if(minioClient.bucketExists(BucketExistsArgs.builder().bucket(newBucket).build())) {
                log.info("Bucket already exists.");
            } else {
                // 创建一个名为ota的存储桶
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(newBucket).build());
                log.info("create a new bucket.");
            }
            //update-begin-author:liusq date:20210809 for: 过滤上传文件类型
            FileTypeFilter.fileTypeFilter(file);
            //update-end-author:liusq date:20210809 for: 过滤上传文件类型
            InputStream stream = file.getInputStream();
            // 获取文件名
            String orgName = file.getOriginalFilename();
            if("".equals(orgName)){
                orgName=file.getName();
            }
            orgName = CommonUtils.getFileName(orgName);
            String objectName = bizPath+"/"
                                +( orgName.indexOf(".")==-1
                                   ?orgName + "_" + System.currentTimeMillis()
                                   :orgName.substring(0, orgName.lastIndexOf(".")) + "_" + System.currentTimeMillis() + orgName.substring(orgName.lastIndexOf("."))
                                 );

            // 使用putObject上传一个本地文件到存储桶中。
            if(objectName.startsWith("/")){
                objectName = objectName.substring(1);
            }
            PutObjectArgs objectArgs = PutObjectArgs.builder().object(objectName)
                    .bucket(newBucket)
                    .contentType("application/octet-stream")
                    .stream(stream,stream.available(),-1).build();
            minioClient.putObject(objectArgs);
            stream.close();
            // file_url = minioUrl+newBucket+"/"+objectName;
            file_url = newBucket+"/"+objectName;
        }catch (Exception e){
            log.error(e.getMessage(), e);
        }
        return file_url;
    }

    /**
     * 文件上传
     * @param file
     * @param bizPath
     * @return
     */
    public static String upload(MultipartFile file, String bizPath) {
        return  upload(file,bizPath,null);
    }

    /**
     * 获取文件流
     * @param bucketName
     * @param objectName
     * @return
     */
    public static InputStream getMinioFile(String bucketName,String objectName){
        InputStream inputStream = null;
        try {
            initMinio(minioUrl, minioName, minioPass);
            GetObjectArgs objectArgs = GetObjectArgs.builder().object(objectName)
                    .bucket(bucketName).build();
            inputStream = minioClient.getObject(objectArgs);
        } catch (Exception e) {
            log.info("文件获取失败" + e.getMessage());
        }
        return inputStream;
    }

    /**
     * 删除文件
     * @param bucketName
     * @param objectName
     * @throws Exception
     */
    public static void removeObject(String bucketName, String objectName) {
        try {
            initMinio(minioUrl, minioName,minioPass);
            RemoveObjectArgs objectArgs = RemoveObjectArgs.builder().object(objectName)
                    .bucket(bucketName).build();
            minioClient.removeObject(objectArgs);
        }catch (Exception e){
            log.info("文件删除失败" + e.getMessage());
        }
    }

    /**
     * 获取文件外链
     * @param bucketName
     * @param objectName
     * @param expires
     * @return
     */
    public static String getObjectURL(String bucketName, String objectName, Integer expires) {
        initMinio(minioUrl, minioName,minioPass);
        try{
            GetPresignedObjectUrlArgs objectArgs = GetPresignedObjectUrlArgs.builder().object(objectName)
                    .bucket(bucketName)
                    .expiry(expires).build();
            String url = minioClient.getPresignedObjectUrl(objectArgs);
            return URLDecoder.decode(url,"UTF-8");
        }catch (Exception e){
            log.info("文件路径获取失败" + e.getMessage());
        }
        return null;
    }

    /**
     * 初始化客户端
     * @param minioUrl
     * @param minioName
     * @param minioPass
     * @return
     */
    private static MinioClient initMinio(String minioUrl, String minioName,String minioPass) {
        if (minioClient == null) {
            try {
                minioClient = MinioClient.builder()
                        .endpoint(minioUrl)
                        .credentials(minioName, minioPass)
                        .build();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return minioClient;
    }

    /**
     * 上传文件到minio
     * @param stream
     * @param relativePath
     * @return
     */
    public static String upload(InputStream stream,String relativePath) throws Exception {
        initMinio(minioUrl, minioName,minioPass);
        if(minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
            log.info("Bucket already exists.");
        } else {
            // 创建一个名为ota的存储桶
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            log.info("create a new bucket.");
        }
        PutObjectArgs objectArgs = PutObjectArgs.builder().object(relativePath)
                .bucket(bucketName)
                .contentType("application/octet-stream")
                .stream(stream,stream.available(),-1).build();
        minioClient.putObject(objectArgs);
        stream.close();
        return minioUrl+bucketName+"/"+relativePath;
    }

    public static String getMinioFileUrl(String filePath) {
        return minioUrl + filePath;
    }
}
